package librairies.arborescence.interfaces;

import librairies.arborescence.arbre.BinarbreDC;
import librairies.liste.interfaces.IListe;

/**
 * definition d'un arbre binaire.
 * 
 * @author mlozach
 * @param <E> type de l'element dans l'arbre
 */
public interface IBinarbre<E extends Comparable<E>> 
{
	/**
	 * retourne la valeur du noeud.
	 * @return E la valeur.
	 */
	public E getVal();
	
	/**
	 * permet de savoir si c'est une feuille.
	 * @return vrai si il n'y a pas de fils.
	 */
	public boolean isLeaf(); 
	
	/**
	 * permet de connaitre le nombre de noeud dans l'arbre.
	 * @return le nombre de noeud.
	 */
	public int familySize();
	
	/**
	 * permet de connaitre la hauteur de l'arbre.
	 * @return la hauteur.
	 */
	public int height();
	
	/**
	 * permet de savoir si l'arbre est equilibre.
	 * @return valeur positive(right) valeur negative(left).
	 */
	public int balance();
	
	/**
	 * permet de retourner le pere du neoud.
	 * @return le pere.
	 */
	public IBinarbre<E> getFather(); 
	
	/**
	 * cherche le pere des peres.
	 * @return le 1er pere.
	 */
	public IBinarbre<E> ancestor(); 
	
	/**
	 * retourne le fils de gauche.
	 * @return le fils de gauche.
	 */
	public IBinarbre<E> getLeft();
	
	/**
	 * retourne le fils de droite.
	 * @return le fils de droite.
	 */
	public IBinarbre<E> getRight(); 
	
	/**
	 * recherche son ou sa soeur potentielle.
	 * @return fere ou soeur.
	 */
	public IBinarbre<E> brother(); 
	
	/**
	 * retourne la liste des peres des peres.
	 * @return la liste des ces peres.
	 */
	public IListe<? extends IBinarbre<E>> ancestors(); 
	
	/**
	 * retourne la liste de tous les noeuds en desous de celui ci jusqu'au niveau n.
	 * @param n le nombre de niveau a descendre.
	 * @return la liste des noeuds.
	 */
	public IListe<? extends IBinarbre<E>> gen(int n);
	
	/**
	 * permet de savoir si la valeur existe.
	 * @param e la valeur a rechercher.
	 * @return vrai si elle existe.
	 */
	public boolean containsVal(E e);
	
	/**
	 * permet de savoir si la liste de valeur existe.
	 * @param liste la liste de valeur.
	 * @return faux si un element n'existe pas.
	 */
	public boolean containsAll(IListe<? extends E> liste);
	
	/**
	 * permet de trouver la valeur la plus grande.
	 * @return la valeur max.
	 */
	public E maxVal();
	
	/**
	 * permet de trouver la valeur la plus petite.
	 * @return la valeur min.
	 */
	public E minVal();
	
	/**
	 * permet d'ajouter un noeud dans l'arbre.
	 * @param e le nouveau noeud.
	 * @return le nouveau arbre.
	 */
	public IBinarbre<E> addVal(E e);
		
	/**
	 * permet d'ajouter des nouveau noeud.
	 * @param l la liste des nouveau noeud.
	 * @return le nouveau arbre.
	 */
	public IBinarbre<E> addAll(IListe<E> l); 
	
	/**
	 * permet de supprimer un fils.
	 * @param e le fils.
	 * @return le nouveau arbre.
	 */
	public IBinarbre<E> cutVal(E e); 
	
	/**
	 * permet de suprimer une liste de fils.
	 * @param l la liste de fils.
	 * @return le nouveau arbre.
	 */
	public IBinarbre<E> cutAll(IListe<E> l);
	
	/**
	 * permet de recuperer les valeurs de l'arbre en commencent par lui-meme.
	 * @return la liste de valeur.
	 */
	public IListe<E> prefixe();	
	
	/**
	 * permet de recuperer les valeurs de l'arbre en mettant lui-meme au millieu.
	 * @return la liste de valeur.
	 */
	public IListe<E> infixe();
	
	/**
	 * permet de recuperer les valeurs de l'arbre en finissant par lui-meme.
	 * @return la liste de valeur.
	 */
	public IListe<E> postfixe();
	
	/**
	 * ?????????
	 * @return ??????????
	 */
	public IListe<E> largeur();
	
	/**
	 * permet d equilibre un peu l'arbre.
	 * @return le nouvelle arbre.
	 */
	public IBinarbre<E> equilibre();

	/**
	 * permet  de modifier le fils de gauche
	 * @param l le nouveau fils
	 */
	public void setLeft(BinarbreDC<E> l);

	/**
	 * permet  de modifier le fils de droite
	 * @param r le nouveau fils
	 */
	public void setRight(BinarbreDC<E> r);

	/**
	 * permet  de modifier le pere
	 * @param f le nouveau pere
	 */
	void setFather(BinarbreDC<E> f);
}